using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("CollectionManager")]
	public class CollectionManager : MonoClass
	{
		[Attribute38("CollectionManager.PreconDeck")]
		public class PreconDeck : MonoClass
		{
			public long m_id => method_2<long>("m_id");

			public long ID => method_11<long>("get_ID", Array.Empty<object>());

			public PreconDeck(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PreconDeck(IntPtr address)
				: this(address, "PreconDeck")
			{
			}
		}

		public enum DeckTag
		{
			Editing,
			Arena
		}

		[Attribute38("CollectionManager.TemplateDeck")]
		public class TemplateDeck : MonoClass
		{
			public int m_id => method_2<int>("m_id");

			public TAG_CLASS m_class => method_2<TAG_CLASS>("m_class");

			public int m_sortOrder => method_2<int>("m_sortOrder");

			public string m_title => method_4("m_title");

			public string m_description => method_4("m_description");

			public string m_displayTexture => method_4("m_displayTexture");

			public TemplateDeck(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TemplateDeck(IntPtr address)
				: this(address, "TemplateDeck")
			{
			}
		}

		[Attribute38("CollectionManager.FindCardsResult")]
		public class FindCardsResult : MonoClass
		{
			public List<CollectibleCard> m_cards => method_3<Class271<CollectibleCard>>("m_cards")?.method_25();

			public bool m_resultsWithoutManaFilterExist => method_2<bool>("m_resultsWithoutManaFilterExist");

			public bool m_resultsWithoutSetFilterExist => method_2<bool>("m_resultsWithoutSetFilterExist");

			public bool m_resultsUnownedExist => method_2<bool>("m_resultsUnownedExist");

			public bool m_resultsInWildExist => method_2<bool>("m_resultsInWildExist");

			public FindCardsResult(IntPtr address, string className)
				: base(address, className)
			{
			}

			public FindCardsResult(IntPtr address)
				: this(address, "FindCardsResult")
			{
			}
		}

		public struct CollectibleCardIndex
		{
			public string CardId;

			public TAG_PREMIUM Premium;
		}

		[Attribute38("CollectionManager.DeckSort")]
		public class DeckSort : MonoClass
		{
			public static int INNKEEPER_DECK_SORT_ORDER => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager/DeckSort", "INNKEEPER_DECK_SORT_ORDER");

			public DeckSort(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DeckSort(IntPtr address)
				: this(address, "DeckSort")
			{
			}

			public int Compare(CollectionDeck a, CollectionDeck b)
			{
				return method_11<int>("Compare", new object[2] { a, b });
			}
		}

		public static int NUM_CARDS_GRANTED_POST_TUTORIAL => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "NUM_CARDS_GRANTED_POST_TUTORIAL");

		public static int NUM_CARDS_TO_UNLOCK_ADVANCED_CM => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "NUM_CARDS_TO_UNLOCK_ADVANCED_CM");

		public static int NUM_EXPERT_CARDS_TO_UNLOCK_CRAFTING => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "NUM_EXPERT_CARDS_TO_UNLOCK_CRAFTING");

		public static int NUM_EXPERT_CARDS_TO_UNLOCK_FORGE => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "NUM_EXPERT_CARDS_TO_UNLOCK_FORGE");

		public static int NUM_BASIC_CARDS_PER_CLASS => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "NUM_BASIC_CARDS_PER_CLASS");

		public static int NUM_CLASS_CARDS_GRANTED_PER_CLASS_UNLOCK => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "NUM_CLASS_CARDS_GRANTED_PER_CLASS_UNLOCK");

		public static int MAX_NUM_TEMPLATE_DECKS => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "MAX_NUM_TEMPLATE_DECKS");

		public static int MAX_DECKS_PER_PLAYER => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "MAX_DECKS_PER_PLAYER");

		public static int NUM_CLASSES => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "NUM_CLASSES");

		public static int DEFAULT_MAX_COPIES_PER_CARD_NORMAL => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "DEFAULT_MAX_COPIES_PER_CARD_NORMAL");

		public static int DEFAULT_MAX_COPIES_PER_CARD_LEGENDARY => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "DEFAULT_MAX_COPIES_PER_CARD_LEGENDARY");

		public static int DEFAULT_MAX_CARDS_PER_DECK => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionManager", "DEFAULT_MAX_CARDS_PER_DECK");

		public static float PENDING_DECK_CONTENTS_REQUEST_THRESHOLD_SECONDS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "CollectionManager", "PENDING_DECK_CONTENTS_REQUEST_THRESHOLD_SECONDS");

		public bool m_cardStacksRegistered => method_2<bool>("m_cardStacksRegistered");

		public bool m_collectionLoaded => method_2<bool>("m_collectionLoaded");

		public List<TAG_CARD_SET> m_displayableCardSets => method_3<Class270<TAG_CARD_SET>>("m_displayableCardSets")?.method_25();

		public List<CollectibleCard> m_collectibleCards => method_3<Class271<CollectibleCard>>("m_collectibleCards")?.method_25();

		public float m_collectionLastModifiedTime => method_2<float>("m_collectionLastModifiedTime");

		public bool m_accountHasWildCards => method_2<bool>("m_accountHasWildCards");

		public float m_lastSearchForWildCardsTime => method_2<float>("m_lastSearchForWildCardsTime");

		public bool m_accountEverHadWildCards => method_2<bool>("m_accountEverHadWildCards");

		public bool m_accountHasRotatedItems => method_2<bool>("m_accountHasRotatedItems");

		public bool m_waitingForBoxTransition => method_2<bool>("m_waitingForBoxTransition");

		public bool m_hasVisitedCollection => method_2<bool>("m_hasVisitedCollection");

		public bool m_editMode => method_2<bool>("m_editMode");

		public bool m_creatingInnkeeperDeck => method_2<bool>("m_creatingInnkeeperDeck");

		public TAG_PREMIUM m_premiumPreference => method_2<TAG_PREMIUM>("m_premiumPreference");

		public DeckRuleset m_deckRuleset => method_3<DeckRuleset>("m_deckRuleset");

		public CollectionManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public CollectionManager(IntPtr address)
			: this(address, "CollectionManager")
		{
		}

		public static void Init()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "CollectionManager", "Init");
		}

		public static CollectionManager Get()
		{
			return MonoClass.smethod_15<CollectionManager>(TritonHs.MainAssemblyPath, "", "CollectionManager", "Get", Array.Empty<object>());
		}

		public void UpdateCardsWithNetData()
		{
			method_8("UpdateCardsWithNetData");
		}

		public void OnCardSale()
		{
			method_8("OnCardSale");
		}

		public void OnMassDisenchantResponse()
		{
			method_8("OnMassDisenchantResponse");
		}

		public void OnSetFavoriteHeroResponse()
		{
			method_8("OnSetFavoriteHeroResponse");
		}

		public void NetCache_OnFavoriteHeroesReceived()
		{
			method_8("NetCache_OnFavoriteHeroesReceived");
		}

		public void UpdateFavoriteHero(TAG_CLASS heroClass, string heroCardId, TAG_PREMIUM premium)
		{
			method_8("UpdateFavoriteHero", heroClass, heroCardId, premium);
		}

		public void NetCache_OnDecksReceived()
		{
			method_8("NetCache_OnDecksReceived");
		}

		public void OnDefaultCardBackSet()
		{
			method_8("OnDefaultCardBackSet");
		}

		public void OnGetDeckContentsResponse()
		{
			method_8("OnGetDeckContentsResponse");
		}

		public void OnDBAction()
		{
			method_8("OnDBAction");
		}

		public void OnDeckCreated()
		{
			method_8("OnDeckCreated");
		}

		public void OnDeckDeleted()
		{
			method_8("OnDeckDeleted");
		}

		public void OnDeckRenamed()
		{
			method_8("OnDeckRenamed");
		}

		public bool IsFullyLoaded()
		{
			return method_11<bool>("IsFullyLoaded", Array.Empty<object>());
		}

		public void RegisterCollectionNetHandlers()
		{
			method_8("RegisterCollectionNetHandlers");
		}

		public void RemoveCollectionNetHandlers()
		{
			method_8("RemoveCollectionNetHandlers");
		}

		public bool HasVisitedCollection()
		{
			return method_11<bool>("HasVisitedCollection", Array.Empty<object>());
		}

		public void SetHasVisitedCollection(bool enable)
		{
			method_8("SetHasVisitedCollection", enable);
		}

		public bool IsWaitingForBoxTransition()
		{
			return method_11<bool>("IsWaitingForBoxTransition", Array.Empty<object>());
		}

		public void NotifyOfBoxTransitionStart()
		{
			method_8("NotifyOfBoxTransitionStart");
		}

		public void OnBoxTransitionFinished(object userData)
		{
			method_8("OnBoxTransitionFinished", userData);
		}

		public void AddCardReward(CardRewardData cardReward, bool markAsNew)
		{
			method_8("AddCardReward", cardReward, markAsNew);
		}

		public float CollectionLastModifiedTime()
		{
			return method_11<float>("CollectionLastModifiedTime", Array.Empty<object>());
		}

		public int EntityDefSortComparison(EntityDef entityDef1, EntityDef entityDef2)
		{
			return method_11<int>("EntityDefSortComparison", new object[2] { entityDef1, entityDef2 });
		}

		public int GetCardTypeSortOrder(EntityDef entityDef)
		{
			return method_11<int>("GetCardTypeSortOrder", new object[1] { entityDef });
		}

		public List<CollectibleCard> GetAllCards()
		{
			return method_14<Class271<CollectibleCard>>("GetAllCards", Array.Empty<object>())?.method_25();
		}

		public TAG_PREMIUM GetBestCardPremium(string cardID)
		{
			return method_11<TAG_PREMIUM>("GetBestCardPremium", new object[1] { cardID });
		}

		public CollectibleCard GetCard(string cardID, TAG_PREMIUM premium)
		{
			return method_14<CollectibleCard>("GetCard", new object[2] { cardID, premium });
		}

		public List<CollectibleCard> GetHeroesIOwn(TAG_CLASS heroClass)
		{
			return method_14<Class271<CollectibleCard>>("GetHeroesIOwn", new object[1] { heroClass })?.method_25();
		}

		public List<CollectibleCard> GetBestHeroesIOwn(TAG_CLASS heroClass)
		{
			return method_14<Class271<CollectibleCard>>("GetBestHeroesIOwn", new object[1] { heroClass })?.method_25();
		}

		public NetCache.CardDefinition GetFavoriteHero(TAG_CLASS heroClass)
		{
			return method_14<NetCache.CardDefinition>("GetFavoriteHero", new object[1] { heroClass });
		}

		public int GetBasicCardsIOwn(TAG_CLASS cardClass)
		{
			return method_11<int>("GetBasicCardsIOwn", new object[1] { cardClass });
		}

		public List<CollectibleCard> GetOwnedCards()
		{
			return method_14<Class271<CollectibleCard>>("GetOwnedCards", Array.Empty<object>())?.method_25();
		}

		public List<TAG_CARD_SET> GetDisplayableCardSets()
		{
			return method_14<Class270<TAG_CARD_SET>>("GetDisplayableCardSets", Array.Empty<object>())?.method_25();
		}

		public bool IsCardInCollection(string cardID, TAG_PREMIUM premium)
		{
			return method_11<bool>("IsCardInCollection", new object[2] { cardID, premium });
		}

		public int GetNumCopiesInCollection(string cardID, TAG_PREMIUM premium)
		{
			return method_11<int>("GetNumCopiesInCollection", new object[2] { cardID, premium });
		}

		public List<CollectibleCard> GetMassDisenchantCards()
		{
			return method_14<Class271<CollectibleCard>>("GetMassDisenchantCards", Array.Empty<object>())?.method_25();
		}

		public int GetCardsToDisenchantCount()
		{
			return method_11<int>("GetCardsToDisenchantCount", Array.Empty<object>());
		}

		public void MarkAllInstancesAsSeen(string cardID, TAG_PREMIUM premium)
		{
			method_8("MarkAllInstancesAsSeen", cardID, premium);
		}

		public void OnCardAdded(string cardID, TAG_PREMIUM premium, int count, bool seenBefore)
		{
			method_8("OnCardAdded", cardID, premium, count, seenBefore);
		}

		public void OnCardRemoved(string cardID, TAG_PREMIUM premium, int count)
		{
			method_8("OnCardRemoved", cardID, premium, count);
		}

		public PreconDeck GetPreconDeck(TAG_CLASS heroClass)
		{
			return method_14<PreconDeck>("GetPreconDeck", new object[1] { heroClass });
		}

		public CollectionDeck GetDeck(long id)
		{
			return method_14<CollectionDeck>("GetDeck", new object[1] { id });
		}

		public bool AreAllDeckContentsReady()
		{
			return method_11<bool>("AreAllDeckContentsReady", Array.Empty<object>());
		}

		public bool ShouldAccountSeeStandardWild()
		{
			return method_11<bool>("ShouldAccountSeeStandardWild", Array.Empty<object>());
		}

		public bool ShouldAccountSeeStandardComingSoon()
		{
			return method_11<bool>("ShouldAccountSeeStandardComingSoon", Array.Empty<object>());
		}

		public bool AccountHasRotatedItems()
		{
			return method_10<bool>("AccountHasRotatedItems", new Class276.Enum20[0], Array.Empty<object>());
		}

		public bool AccountHasRotatedItems(DateTime localTimestamp)
		{
			return method_10<bool>("AccountHasRotatedItems", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { localTimestamp });
		}

		public bool AccountEverHadWildCards()
		{
			return method_11<bool>("AccountEverHadWildCards", Array.Empty<object>());
		}

		public bool AccountHasWildCards()
		{
			return method_11<bool>("AccountHasWildCards", Array.Empty<object>());
		}

		public int GetNumberOfWildDecks()
		{
			return method_11<int>("GetNumberOfWildDecks", Array.Empty<object>());
		}

		public int GetNumberOfStandardDecks()
		{
			return method_11<int>("GetNumberOfStandardDecks", Array.Empty<object>());
		}

		public bool AccountHasValidStandardDeck()
		{
			return method_11<bool>("AccountHasValidStandardDeck", Array.Empty<object>());
		}

		public bool AccountHasAnyValidDeck()
		{
			return method_11<bool>("AccountHasAnyValidDeck", Array.Empty<object>());
		}

		public CollectionDeck GetTaggedDeck(DeckTag tag)
		{
			return method_14<CollectionDeck>("GetEditedDeck", Array.Empty<object>());
		}

		public CollectionDeck GetEditedDeck()
		{
			return method_14<CollectionDeck>("GetEditedDeck", Array.Empty<object>());
		}

		public int GetDeckSize()
		{
			return method_11<int>("GetDeckSize", Array.Empty<object>());
		}

		public List<TemplateDeck> GetTemplateDecks(TAG_CLASS classType)
		{
			return method_14<Class271<TemplateDeck>>("GetTemplateDecks", new object[1] { classType })?.method_25();
		}

		public bool IsInEditMode()
		{
			return method_11<bool>("IsInEditMode", Array.Empty<object>());
		}

		public CollectionDeck StartEditingDeck(DeckTag tag, long deckId, object callbackData)
		{
			return method_14<CollectionDeck>("StartEditingDeck", new object[3] { tag, deckId, callbackData });
		}

		public void DoneEditing()
		{
			method_8("DoneEditing");
		}

		public DeckRuleset GetDeckRuleset()
		{
			return method_14<DeckRuleset>("GetDeckRuleset", Array.Empty<object>());
		}

		public bool IsShowingWildTheming(CollectionDeck deck)
		{
			return method_11<bool>("IsShowingWildTheming", new object[1] { deck });
		}

		public void SetDeckRuleset(DeckRuleset deckRuleset)
		{
			method_8("SetDeckRuleset", deckRuleset);
		}

		public CollectionDeck SetTaggedDeck(DeckTag tag, long deckId, object callbackData)
		{
			return method_15<CollectionDeck>("SetTaggedDeck", new Class276.Enum20[3]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.I8,
				Class276.Enum20.Class
			}, new object[3] { tag, deckId, callbackData });
		}

		public void SetTaggedDeck(DeckTag tag, CollectionDeck deck, object callbackData)
		{
			method_9("SetTaggedDeck", new Class276.Enum20[3]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, tag, deck, callbackData);
		}

		public void ClearTaggedDeck(DeckTag tag)
		{
			method_8("ClearTaggedDeck", tag);
		}

		public void SendDeleteDeck(long id)
		{
			method_8("SendDeleteDeck", id);
		}

		public void RequestDeckContents(long id)
		{
			method_8("RequestDeckContents", id);
		}

		public CollectionDeck GetBaseDeck(long id)
		{
			return method_14<CollectionDeck>("GetBaseDeck", new object[1] { id });
		}

		public string AutoGenerateDeckName(TAG_CLASS classTag)
		{
			return method_13("AutoGenerateDeckName", classTag);
		}

		public string GetVanillaHeroCardIDFromClass(TAG_CLASS heroClass)
		{
			return method_13("GetVanillaHeroCardIDFromClass", heroClass);
		}

		public string GetVanillaHeroCardID(EntityDef HeroSkinEntityDef)
		{
			return method_13("GetVanillaHeroCardID", HeroSkinEntityDef);
		}

		public bool ShouldShowDeckTemplatePageForClass(TAG_CLASS classType)
		{
			return method_11<bool>("ShouldShowDeckTemplatePageForClass", new object[1] { classType });
		}

		public void SetShowDeckTemplatePageForClass(TAG_CLASS classType, bool show)
		{
			method_8("SetShowDeckTemplatePageForClass", classType, show);
		}

		public bool ShouldShowWildToStandardTutorial(bool checkPrevSceneIsPlayMode)
		{
			return method_11<bool>("ShouldShowWildToStandardTutorial", new object[1] { checkPrevSceneIsPlayMode });
		}

		public void InitImpl()
		{
			method_8("InitImpl");
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public void OnCollectionChanged()
		{
			method_8("OnCollectionChanged");
		}

		public int NumCardsOwnedInSet(TAG_CARD_SET cardSet)
		{
			return method_11<int>("NumCardsOwnedInSet", new object[1] { cardSet });
		}

		public CollectibleCard RegisterCard(EntityDef entityDef, string cardID, TAG_PREMIUM premium)
		{
			return method_14<CollectibleCard>("RegisterCard", new object[3] { entityDef, cardID, premium });
		}

		public CollectibleCard AddCounts(NetCache.CardStack netStack, EntityDef entityDef)
		{
			return method_15<CollectibleCard>("AddCounts", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, new object[2] { netStack, entityDef });
		}

		public CollectibleCard AddCounts(EntityDef entityDef, string cardID, TAG_PREMIUM premium, DateTime insertDate, int count, int numSeen)
		{
			return method_15<CollectibleCard>("AddCounts", new Class276.Enum20[6]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.ValueType,
				Class276.Enum20.ValueType,
				Class276.Enum20.I4,
				Class276.Enum20.I4
			}, new object[6] { entityDef, cardID, premium, insertDate, count, numSeen });
		}

		public void AddPreconDeckFromNotice(NetCache.ProfileNoticePreconDeck preconDeckNotice)
		{
			method_8("AddPreconDeckFromNotice", preconDeckNotice);
		}

		public void AddPreconDeck(TAG_CLASS heroClass, long deckID)
		{
			method_8("AddPreconDeck", heroClass, deckID);
		}

		public CollectionDeck AddDeck(NetCache.DeckHeader deckHeader)
		{
			return method_15<CollectionDeck>("AddDeck", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { deckHeader });
		}

		public CollectionDeck AddDeck(NetCache.DeckHeader deckHeader, bool updateNetCache)
		{
			return method_15<CollectionDeck>("AddDeck", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, new object[2] { deckHeader, updateNetCache });
		}

		public void RemoveDeck(long id)
		{
			method_8("RemoveDeck", id);
		}

		public void LogAllDeckStringsInCollection()
		{
			method_8("LogAllDeckStringsInCollection");
		}

		public bool IsDeckNameTaken(string name)
		{
			return method_11<bool>("IsDeckNameTaken", new object[1] { name });
		}

		public void FireDeckContentsEvent(long id)
		{
			method_8("FireDeckContentsEvent", id);
		}

		public void FireAllDeckContentsEvent()
		{
			method_8("FireAllDeckContentsEvent");
		}

		public void OnNetCacheReady()
		{
			method_8("OnNetCacheReady");
		}

		public void FixedRewardsStartupComplete()
		{
			method_8("FixedRewardsStartupComplete");
		}

		public void UpdateShowAdvancedCMOption()
		{
			method_8("UpdateShowAdvancedCMOption");
		}

		public void UpdateDeckHeroArt(string heroCardID)
		{
			method_8("UpdateDeckHeroArt", heroCardID);
		}

		public void InsertNewCollectionCard(string cardID, TAG_PREMIUM premium, DateTime insertDate, int count, bool seenBefore)
		{
			method_8("InsertNewCollectionCard", cardID, premium, insertDate, count, seenBefore);
		}

		public void RemoveCollectionCard(string cardID, TAG_PREMIUM premium, int count)
		{
			method_8("RemoveCollectionCard", cardID, premium, count);
		}

		public void UpdateCardCounts(NetCache.NetCacheCollection netCacheCards, NetCache.CardDefinition cardDef, int count, int newCount)
		{
			method_8("UpdateCardCounts", netCacheCards, cardDef, count, newCount);
		}

		public void NotifyNetCacheOfRemovedCards(NetCache.CardDefinition cardDef, int count)
		{
			method_8("NotifyNetCacheOfRemovedCards", cardDef, count);
		}

		public void NotifyNetCacheOfNewCards(NetCache.CardDefinition cardDef, long insertDate, int count, bool seenBefore)
		{
			method_8("NotifyNetCacheOfNewCards", cardDef, insertDate, count, seenBefore);
		}

		public void LoadTemplateDecks()
		{
			method_8("LoadTemplateDecks");
		}

		public void AutoGenerateNewDeckForPlayer()
		{
			method_8("AutoGenerateNewDeckForPlayer");
		}

		public TAG_PREMIUM GetPreferredPremium()
		{
			return method_11<TAG_PREMIUM>("GetPreferredPremium", Array.Empty<object>());
		}

		public TAG_PREMIUM GetUnPreferredPremium()
		{
			return method_11<TAG_PREMIUM>("GetUnPreferredPremium", Array.Empty<object>());
		}

		public void SetPremiumPreference(TAG_PREMIUM premium)
		{
			method_8("SetPremiumPreference", premium);
		}

		public void FillInnkeeperDeck(CollectionDeck deck)
		{
			method_8("FillInnkeeperDeck", deck);
		}
	}
}
